#include <iostream>
#include <tuple>
#include <vector>

namespace basicC {
	using namespace std;
	namespace templateLearn {
		
		template<typename T>
		using VT = vector<T>;

		template<typename... Types>
		using store = tuple<vector<Types>...>;

		template <typename Tuple, typename Func, size_t ... N>
		void func_call_tuple(const Tuple& t, Func&& func, std::index_sequence<N...>) {
			static_cast<void>(std::initializer_list<int>{(func(std::get<N>(t)), 0)...});
		}

		template <typename ... Args, typename Func>
		void travel_tuple(const std::tuple<Args...>& t, Func&& func) {
			func_call_tuple(t, std::forward<Func>(func), std::make_index_sequence<sizeof...(Args)>{});
		}
		

		void demo()
		{
			
			store<> a;
			store<int> b;
			store<int, double> c{ {1,3,5}, {2.0, 4.0, 5.0} };

			VT<int> vi{ 100,200,300 };
			for (const auto& item : vi)
			{
				cout << item << endl;
			}
			cout << "\n";

			auto count = tuple_size<decltype(c)>::value;
		//	for (size_t i = 0; i < count; i++)				auto vt = get<i>(c); //不允许迭代
			VT<int> vt1; VT<double> vt2;
			tie(vt1, vt2) = c;
			for (const auto& item : vt1)cout << item << "\t";
			cout << "\n";
			for (const auto& item : vt2)cout << item << "\t";
			cout << "\n";

			tuple<int, char, double> mytuple(10, 'a', 3.14);

			cout << "\nmytuple has ";
			cout << tuple_size<decltype(mytuple)>::value;
			cout << " elements." << "\n";
			//获取元素
			cout << "the elements is: ";
			cout << get<0>(mytuple) << " ";
			cout << get<1>(mytuple) << " ";
			cout << get<2>(mytuple) << " ";
			int ages;
			tie(ignore, ages, ignore) = mytuple;
			cout << "ages " << ages << "\n\n";

			auto t = std::make_tuple(1, 4.56, "happen lee");
			travel_tuple(t, [](auto&& item) {
				cout << item << ",\t";
				});

			wcout << L"\n\nlong long最大值：" << LLONG_MIN << " " << hex << LLONG_MIN << "\n";
			wcout << L"long long最小值：" << dec << LLONG_MAX << " " << hex << LLONG_MAX << "\n";
			wcout <<  L"unsigned long long最大值：" << dec << ULLONG_MAX << " " << hex << ULLONG_MAX << "\n";
		}
	}

	namespace sizeofLearn {
		/*
		(0)sizeof是运算符，不是函数；

(1)sizeof不能求得void类型的长度；

(2)sizeof能求得void类型的指针的长度；

(3)sizeof能求得静态分配内存的数组的长度!

(4)sizeof不能求得动态分配的内存的大小!

(5)sizeof不能对不完整的数组求长度；

(6)当表达式作为sizeof的操作数时，它返回表达式的计算结果的类型大小，但是它不对表达式求值！

(7)sizeof可以对函数调用求大小，并且求得的大小等于返回类型的大小，但是不执行函数体！

(8)sizeof求得的结构体(及其对象)的大小并不等于各个数据成员对象的大小之和！

(9)sizeof不能用于求结构体的位域成员的大小，但是可以求得包含位域成员的结构体的大小！

	
		*/
		//试图让bool类型的变量b只占用1个bit，让ch1和ch2分别只占用4个bit，以此来达到对内存精打细算的功能(事实上使用位域对内存精打细算有时候能成功，有时候却未必成功
		//sizeof以byte为单位返回操作数的大小！
		class Person {
			bool b : 1;//1bit
			char ch1 : 4;  //4bit
			char ch2 : 4;  //4bit
		};
		void demo()
		{
			//所有指针，大小都一样，64位系统，8位。
			wcout << L"\n\n 所有指针，大小都一样，64位系统，8位 \n";
			cout << sizeof(int*) << endl;
			cout << sizeof(void*) << endl;
			cout << sizeof(double*) << endl;
			cout << sizeof(Person*) << endl;

			{
			int a[10]; 
			int n = sizeof(a);
			cout << "\n\n int a[10];  sizeof(a) \n\t";
			cout << sizeof(a) << endl;

			Person p[20];
			int n1 = sizeof(p) / sizeof(p[0]);
			cout << "\n\n Person p[20];  sizeof(p) / sizeof(p[0]); \n\t";
			cout << n1 << endl;

			char ch[] ="abc"; 
			sizeof(ch);
			cout << "\n  char ch[] ='abc' sizeof(ch) \n\t";
			cout << sizeof(ch) << endl;

			auto fun = [](int array[10])
			{
				int n = sizeof(array);
				cout << "\n  [](int array[10])  sizeof(array)\n\t";
				cout << sizeof(array) << endl;
				return n;
			};
			cout << "\n sizeof(fun)\n\t";
			cout << sizeof(fun) << endl;
			
			fun(a);
			cout << "\n  sizeof(fun(a)) \n\t";
			cout << sizeof(fun(a)) << endl; //不执行fun
			
			}

			{
				char ch = 1;
				int num = 5;
				int n1 = sizeof(ch + num);  //sizeof返回的是表达式计算结果的类型大小，而不是表达式中占用最大内存的变量的类型大小！
				int n2 = sizeof(ch = ch + num);//不对表达式求值,只计算类型
				cout << "\n sizeof(ch + num)\n\t";
				cout << n1 << endl;
				cout << n2<< endl;
				cout << hex <<ch ;
				cout << "\n ";
			}
			
			cout << "\n sizeof(Person)\n\t";
			cout << sizeof(Person) << endl;

			cout << "\n\n ";
		}
		
	}
}